package tools;

/**
 * @Author: Painter
 * @project_name: testproject
 * @system_login: sunshine
 * @time: 2022-05-14-001418:30
 */


public class CustomArray {
    public CustomArray() {
    }

    // 获取数组的最大值
    public static int intmax(int[] arrys) {
        // 求出数组的最大值和最小值

        // 获取数组的最大值
        int max = arrys[0];
        for (int i = 0; i < arrys.length; i++) {
            if (arrys[i] > max) {
                max = arrys[i];
            }
        }
        return max;
    }

    // 获取数组的最小值
    public static int intmix(int[] arrys) {
        // 获取数组的最小值
        int mix = arrys[0];
        for (int i = 0; i < arrys.length; i++) {
            if (mix > arrys[i]) {
                mix = arrys[i];
            }
        }
        return mix;
    }

    // 获取给定元素在数组中的出现的所有索引字符串
    public static String[] inquireints(int[] arrgy, int val) {
        /**
         *    给出两个参数 返回一个数组 数组中包含查询的数组元素在数组中的下标
         *
         *     arrgy :  整数类型的数组
         *     val   :  查询的数组元素
         *     返回一个字符串数组  输出所有符合要求的数据
         * */

        int len = arrgy.length;   // 形参数组长度
        int n = 0;
        int val2 = 0;
        String[] str = new String[len];   // 新建一个返回长度 为查询元素信息的数组
        for (int i = 0; i < len; i++) {   // for循环 循环次数是形参数组的长度
            if (arrgy[i] == val) {   // 如果在形参数组指定索引的元素与查询的元素相等
                str[n] = "查询到元素 " + val + " 在指定数组中的第 " + (n + 1) + " 个索引位置为 " + i;   // 更改
                n++;
            }
        }
        String[] str2 = new String[n];
        System.arraycopy(str, 0, str2, 0, str2.length);
        /**拷贝数组str到数组str2   两个零表示 拷贝的元素和元素的索引不会改变 ，拷贝后的长度为被拷贝的数组str2的长度
         * @param      src      源数组。
         * @param      srcPos   源数组中的起始位置。  默认 0
         * @param      dest     目标数组
         * @param      destPos  目标数据中的起始位置。 默认 0
         * @param      length   要复制的数组元素的数量   一般设置长度小的数组的长度
         * */

        return str2;
    }

    // 获取给出元素在给出数组中的索引  整数类型
    public static int inquireinteger(int[] arrys, int intval) {
        /**
         * 获取给出元素在给出数组中的索引，如果元素有重复那么给出最后一次出现的索引
         *
         */


        int val1 = -1;
        for (int i = 0; i < arrys.length; i++) {
            if (arrys[i] == intval) {
                val1 = i;
            }
        }
        return val1;
    }

    // 获取给出元素在给出数组中的索引  字符类型
    public static int inquirechar(char[] chararr, char charval) {
        /**
         * 获取给出元素在给出数组中的索引，如果元素有重复那么给出最后一次出现的索引
         *
         */
        int val1 = -1;
        for (int i = 0; i < chararr.length; i++) {
            if (chararr[i] == charval) {
                val1 = i;
            }
        }
        return val1;
    }

    // 向数组指定索引位置添加元素  整数类型
    public static int[] addinitegerelement(int[] arr, int addindex, int addval) {
        /**
         * @param  arr              int数组 源数组   在这个数组里添加元素
         * @param  addindex         添加元素的索引位置，在什么位置上添加元素
         * @param  addval           添加的值
         *
         * 向指定位置添加元素
         * 通过arr，创建一个新数组arrnew，arrnew的长度为arr数组长度加一
         * 将arr数组的addindex之前的元素赋值到arrnew
         * 将arrnew的addindex位置上赋值为addval
         * 将arr的addindex位置以后的元素索引全部加一，赋值到arrnew
         * */

        int[] arrnew = new int[arr.length + 1];   // 创建一个新数组

        int arrindex = 0;       // arr数组的索引
        int arrnewindex = 0;    // arrnew数组的索引

        // 遍历arrnew数组，将arr数组索引为addindex之前的元素赋值到arrnew，
        // 将arr索引为addindex之后（包括addindex位置的元素）所有元素的索引加1并赋值到arrnew，将arrnew索引为addindex的位置赋值为addval
        for (int i = 0; i < arrnew.length; i++) {     // 遍历arrnew数组，
            if (i == addindex) {    // 如果索引是addindex
                arrnew[addindex] = addval;   // 将添加的元素赋值到arrnew的addindex位置上
                arrnewindex += 1;   // 将addindex之后（包括addindex位置的元素）的元素的索引加1
            } else {   // 将addindex索引位置之前的元素赋值到arrnew
                arrnew[arrnewindex] = arr[arrindex];   // 将arr的元素赋值到arrnew，
                arrindex++;    // 索引加1
                arrnewindex++;  // 索引加1
            }
        }
        return arrnew;
    }

    // 向数组指定索引位置添加元素  字符类型
    public static char[] addcharelement(char[] arr, int addindex, char addval) {
        /**
         * @param  arr              int数组 源数组   在这个数组里添加元素
         * @param  addindex         添加元素的索引位置，在什么位置上添加元素
         * @param  addval           添加的值
         *
         * 向指定位置添加元素
         * 通过arr，创建一个新数组arrnew，arrnew的长度为arr数组长度加一
         * 将arr数组的addindex之前的元素赋值到arrnew
         * 将arrnew的addindex位置上赋值为addval
         * 将arr的addindex位置以后的元素索引全部加一，赋值到arrnew
         * */

        char[] arrnew = new char[arr.length + 1];   // 创建一个新数组

        int arrindex = 0;       // arr数组的索引
        int arrnewindex = 0;    // arrnew数组的索引

        // 遍历arrnew数组，将arr数组索引为addindex之前的元素赋值到arrnew，
        // 将arr索引为addindex之后（包括addindex位置的元素）所有元素的索引加1并赋值到arrnew，将arrnew索引为addindex的位置赋值为addval
        for (int i = 0; i < arrnew.length; i++) {     // 遍历arrnew数组，
            if (i == addindex) {    // 如果索引是addindex
                arrnew[addindex] = addval;   // 将添加的元素赋值到arrnew的addindex位置上
                arrnewindex += 1;   // 将addindex之后（包括addindex位置的元素）的元素的索引加1
            } else {   // 将addindex索引位置之前的元素赋值到arrnew
                arrnew[arrnewindex] = arr[arrindex];   // 将arr的元素赋值到arrnew，
                arrindex++;    // 索引加1
                arrnewindex++;  // 索引加1
            }
        }
        return arrnew;
    }

    // 向数组末尾位置添加元素  整数类型
    public static int[] addintegerelements(int[] arr, int addval) {

        // 将需要添加的值添加到指定数组的尾部
        //  arr 数组    addval  添加的值


        int[] arrnew = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            arrnew[i] = arr[i];
        }
        arrnew[arrnew.length - 1] = addval;
        return arrnew;
    }

    // 向数组末尾位置添加元素  字符类型
    public static char[] addcharelements(char[] arr, char addval) {

        // 将需要添加的值添加到指定数组的尾部
        //  arr 数组    addval  添加的值


        char[] arrnew = new char[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            arrnew[i] = arr[i];
        }
        arrnew[arrnew.length - 1] = addval;
        return arrnew;
    }

    // 向数组末尾位置添加一个数组中的所有元素  整数类型
    public static int[] addintegerelementss(int[] arr, int[] addarrs) {
        // 将数组addars里的所有元素添加到 数组arr 的尾部

        int[] arrnew = new int[arr.length + addarrs.length];
        int num = 0;
        for (int val : addarrs) {
            System.arraycopy(arr, 0, arrnew, 0, arr.length);
            /**  拷贝数组arr到数组arrnew   两个零表示 拷贝的元素和元素的索引不会改变 ，拷贝后的长度为被拷贝的数组arr的长度
             * @param      src      源数组。
             * @param      srcPos   源数组中的起始位置。  默认 0
             * @param      dest     目标数组
             * @param      destPos  目标数据中的起始位置。 默认 0
             * @param      length   要复制的数组元素的数量  一般设置长度小的数组的长度
             * */
//            for (int i = 0; i < arr.length; i++) {
//                arrnew[i] = arr[i];
//            }
            arrnew[arr.length + num] = val;
            num++;
        }
        return arrnew;
    }

    // 向数组末尾位置添加一个数组中的所有元素  字符类型
    public static char[] addcharelementss(char[] arr, char[] addarrs) {
        // 将数组addars里的所有元素添加到 数组arr 的尾部

        char[] arrnew = new char[arr.length + addarrs.length];
        int num = 0;
        for (char val : addarrs) {
            System.arraycopy(arr, 0, arrnew, 0, arr.length);
            /**  拷贝数组arr到数组arrnew   两个零表示 拷贝的元素和元素的索引不会改变 ，拷贝后的长度为被拷贝的数组arr的长度
             * @param      src      源数组。
             * @param      srcPos   源数组中的起始位置。  默认 0
             * @param      dest     目标数组
             * @param      destPos  目标数据中的起始位置。 默认 0
             * @param      length   要复制的数组元素的数量  一般设置长度小的数组的长度
             * */
//            for (int i = 0; i < arr.length; i++) {
//                arrnew[i] = arr[i];
//            }
            arrnew[arr.length + num] = val;
            num++;
        }
        return arrnew;
    }

    // 删除指定索引的元素
    public static int[] remove(int[] arr, int index) {


        // 删除指定索引的元素

        int[] arrnew = new int[arr.length - 1];

        int arrnewindex = 0;
        int arrindex = 0;
        for (int i = 0; i < arr.length; i++) {
            if (i == index) {
                arrindex++;
            } else {
                arrnew[arrnewindex] = arr[arrindex];
                arrindex++;
                arrnewindex++;
            }
        }
        return arrnew;
    }

    // 删除指定元素
    public static int[] removes(int[] arr, int val) {

        // 删除指定元素

        int index = 0;
        int[] arrnew = new int[arr.length - 1];
        for (int j : arr) {
            if (j == val) {
                int arrnewindex = 0;
                int arrindex = 0;
                for (int i = 0; i < arr.length; i++) {
                    if (i == index) {
                        arrindex++;
                    } else {
                        arrnew[arrnewindex] = arr[arrindex];
                        arrindex++;
                        arrnewindex++;
                    }
                }
            }
            index++;
        }
        return arrnew;
    }
}
